home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / sre_compile.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  10.9 KB  |  546 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Internal support module for sre'''
  5. import _sre
  6. import sys
  7. from sre_constants import *
  8. if _sre.CODESIZE == 2:
  9.     MAXCODE = 65535
  10. else:
  11.     MAXCODE = 0xFFFFFFFFL
  12.  
  13. def _identityfunction(x):
  14.     return x
  15.  
  16.  
  17. def _compile(code, pattern, flags):
  18.     emit = code.append
  19.     _len = len
  20.     LITERAL_CODES = {
  21.         LITERAL: 1,
  22.         NOT_LITERAL: 1 }
  23.     REPEATING_CODES = {
  24.         REPEAT: 1,
  25.         MIN_REPEAT: 1,
  26.         MAX_REPEAT: 1 }
  27.     SUCCESS_CODES = {
  28.         SUCCESS: 1,
  29.         FAILURE: 1 }
  30.     ASSERT_CODES = {
  31.         ASSERT: 1,
  32.         ASSERT_NOT: 1 }
  33.     for op, av in pattern:
  34.         if op in LITERAL_CODES:
  35.             if flags & SRE_FLAG_IGNORECASE:
  36.                 emit(OPCODES[OP_IGNORE[op]])
  37.                 emit(_sre.getlower(av, flags))
  38.             else:
  39.                 emit(OPCODES[op])
  40.                 emit(av)
  41.         flags & SRE_FLAG_IGNORECASE
  42.         if op is IN:
  43.             if flags & SRE_FLAG_IGNORECASE:
  44.                 emit(OPCODES[OP_IGNORE[op]])
  45.                 
  46.                 def fixup(literal, flags = flags):
  47.                     return _sre.getlower(literal, flags)
  48.  
  49.             else:
  50.                 emit(OPCODES[op])
  51.                 fixup = _identityfunction
  52.             skip = _len(code)
  53.             emit(0)
  54.             _compile_charset(av, flags, code, fixup)
  55.             code[skip] = _len(code) - skip
  56.             continue
  57.         if op is ANY:
  58.             if flags & SRE_FLAG_DOTALL:
  59.                 emit(OPCODES[ANY_ALL])
  60.             else:
  61.                 emit(OPCODES[ANY])
  62.         flags & SRE_FLAG_DOTALL
  63.         if op in REPEATING_CODES:
  64.             if flags & SRE_FLAG_TEMPLATE:
  65.                 raise error, 'internal: unsupported template operator'
  66.                 emit(OPCODES[REPEAT])
  67.                 skip = _len(code)
  68.                 emit(0)
  69.                 emit(av[0])
  70.                 emit(av[1])
  71.                 _compile(code, av[2], flags)
  72.                 emit(OPCODES[SUCCESS])
  73.                 code[skip] = _len(code) - skip
  74.             elif _simple(av) and op is not REPEAT:
  75.                 if op is MAX_REPEAT:
  76.                     emit(OPCODES[REPEAT_ONE])
  77.                 else:
  78.                     emit(OPCODES[MIN_REPEAT_ONE])
  79.                 skip = _len(code)
  80.                 emit(0)
  81.                 emit(av[0])
  82.                 emit(av[1])
  83.                 _compile(code, av[2], flags)
  84.                 emit(OPCODES[SUCCESS])
  85.                 code[skip] = _len(code) - skip
  86.             else:
  87.                 emit(OPCODES[REPEAT])
  88.                 skip = _len(code)
  89.                 emit(0)
  90.                 emit(av[0])
  91.                 emit(av[1])
  92.                 _compile(code, av[2], flags)
  93.                 code[skip] = _len(code) - skip
  94.                 if op is MAX_REPEAT:
  95.                     emit(OPCODES[MAX_UNTIL])
  96.                 else:
  97.                     emit(OPCODES[MIN_UNTIL])
  98.         op is MAX_REPEAT
  99.         if op is SUBPATTERN:
  100.             if av[0]:
  101.                 emit(OPCODES[MARK])
  102.                 emit((av[0] - 1) * 2)
  103.             
  104.             _compile(code, av[1], flags)
  105.             if av[0]:
  106.                 emit(OPCODES[MARK])
  107.                 emit((av[0] - 1) * 2 + 1)
  108.             
  109.         av[0]
  110.         if op in SUCCESS_CODES:
  111.             emit(OPCODES[op])
  112.             continue
  113.         if op in ASSERT_CODES:
  114.             emit(OPCODES[op])
  115.             skip = _len(code)
  116.             emit(0)
  117.             if av[0] >= 0:
  118.                 emit(0)
  119.             else:
  120.                 (lo, hi) = av[1].getwidth()
  121.                 if lo != hi:
  122.                     raise error, 'look-behind requires fixed-width pattern'
  123.                 
  124.                 emit(lo)
  125.             _compile(code, av[1], flags)
  126.             emit(OPCODES[SUCCESS])
  127.             code[skip] = _len(code) - skip
  128.             continue
  129.         if op is CALL:
  130.             emit(OPCODES[op])
  131.             skip = _len(code)
  132.             emit(0)
  133.             _compile(code, av, flags)
  134.             emit(OPCODES[SUCCESS])
  135.             code[skip] = _len(code) - skip
  136.             continue
  137.         if op is AT:
  138.             emit(OPCODES[op])
  139.             if flags & SRE_FLAG_MULTILINE:
  140.                 av = AT_MULTILINE.get(av, av)
  141.             
  142.             if flags & SRE_FLAG_LOCALE:
  143.                 av = AT_LOCALE.get(av, av)
  144.             elif flags & SRE_FLAG_UNICODE:
  145.                 av = AT_UNICODE.get(av, av)
  146.             
  147.             emit(ATCODES[av])
  148.             continue
  149.         if op is BRANCH:
  150.             emit(OPCODES[op])
  151.             tail = []
  152.             tailappend = tail.append
  153.             for av in av[1]:
  154.                 skip = _len(code)
  155.                 emit(0)
  156.                 _compile(code, av, flags)
  157.                 emit(OPCODES[JUMP])
  158.                 tailappend(_len(code))
  159.                 emit(0)
  160.                 code[skip] = _len(code) - skip
  161.             
  162.             emit(0)
  163.             for tail in tail:
  164.                 code[tail] = _len(code) - tail
  165.             
  166.         if op is CATEGORY:
  167.             emit(OPCODES[op])
  168.             if flags & SRE_FLAG_LOCALE:
  169.                 av = CH_LOCALE[av]
  170.             elif flags & SRE_FLAG_UNICODE:
  171.                 av = CH_UNICODE[av]
  172.             
  173.             emit(CHCODES[av])
  174.             continue
  175.         if op is GROUPREF:
  176.             if flags & SRE_FLAG_IGNORECASE:
  177.                 emit(OPCODES[OP_IGNORE[op]])
  178.             else:
  179.                 emit(OPCODES[op])
  180.             emit(av - 1)
  181.             continue
  182.         if op is GROUPREF_EXISTS:
  183.             emit(OPCODES[op])
  184.             emit(av[0] - 1)
  185.             skipyes = _len(code)
  186.             emit(0)
  187.             _compile(code, av[1], flags)
  188.             if av[2]:
  189.                 emit(OPCODES[JUMP])
  190.                 skipno = _len(code)
  191.                 emit(0)
  192.                 code[skipyes] = (_len(code) - skipyes) + 1
  193.                 _compile(code, av[2], flags)
  194.                 code[skipno] = _len(code) - skipno
  195.             else:
  196.                 code[skipyes] = (_len(code) - skipyes) + 1
  197.         av[2]
  198.         raise ValueError, ('unsupported operand type', op)
  199.     
  200.  
  201.  
  202. def _compile_charset(charset, flags, code, fixup = None):
  203.     emit = code.append
  204.     if fixup is None:
  205.         fixup = _identityfunction
  206.     
  207.     for op, av in _optimize_charset(charset, fixup):
  208.         emit(OPCODES[op])
  209.         if op is NEGATE:
  210.             continue
  211.         if op is LITERAL:
  212.             emit(fixup(av))
  213.             continue
  214.         if op is RANGE:
  215.             emit(fixup(av[0]))
  216.             emit(fixup(av[1]))
  217.             continue
  218.         if op is CHARSET:
  219.             code.extend(av)
  220.             continue
  221.         if op is BIGCHARSET:
  222.             code.extend(av)
  223.             continue
  224.         if op is CATEGORY:
  225.             if flags & SRE_FLAG_LOCALE:
  226.                 emit(CHCODES[CH_LOCALE[av]])
  227.             elif flags & SRE_FLAG_UNICODE:
  228.                 emit(CHCODES[CH_UNICODE[av]])
  229.             else:
  230.                 emit(CHCODES[av])
  231.         flags & SRE_FLAG_LOCALE
  232.         raise error, 'internal: unsupported set operator'
  233.     
  234.     emit(OPCODES[FAILURE])
  235.  
  236.  
  237. def _optimize_charset(charset, fixup):
  238.     out = []
  239.     outappend = out.append
  240.     charmap = [
  241.         0] * 256
  242.     
  243.     try:
  244.         for op, av in charset:
  245.             if op is NEGATE:
  246.                 outappend((op, av))
  247.                 continue
  248.             if op is LITERAL:
  249.                 charmap[fixup(av)] = 1
  250.                 continue
  251.             if op is RANGE:
  252.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  253.                     charmap[i] = 1
  254.                 
  255.             if op is CATEGORY:
  256.                 return charset
  257.                 continue
  258.     except IndexError:
  259.         return _optimize_unicode(charset, fixup)
  260.  
  261.     i = p = n = 0
  262.     runs = []
  263.     runsappend = runs.append
  264.     for c in charmap:
  265.         if c:
  266.             if n == 0:
  267.                 p = i
  268.             
  269.             n = n + 1
  270.         elif n:
  271.             runsappend((p, n))
  272.             n = 0
  273.         
  274.         i = i + 1
  275.     
  276.     if n:
  277.         runsappend((p, n))
  278.     
  279.     if len(runs) <= 2:
  280.         for p, n in runs:
  281.             if n == 1:
  282.                 outappend((LITERAL, p))
  283.                 continue
  284.             outappend((RANGE, (p, p + n - 1)))
  285.         
  286.         if len(out) < len(charset):
  287.             return out
  288.         
  289.     else:
  290.         data = _mk_bitmap(charmap)
  291.         outappend((CHARSET, data))
  292.         return out
  293.     return charset
  294.  
  295.  
  296. def _mk_bitmap(bits):
  297.     data = []
  298.     dataappend = data.append
  299.     if _sre.CODESIZE == 2:
  300.         start = (1, 0)
  301.     else:
  302.         start = (0x1L, 0x0L)
  303.     (m, v) = start
  304.     for c in bits:
  305.         if c:
  306.             v = v + m
  307.         
  308.         m = m + m
  309.         if m > MAXCODE:
  310.             dataappend(v)
  311.             (m, v) = start
  312.             continue
  313.     
  314.     return data
  315.  
  316.  
  317. def _optimize_unicode(charset, fixup):
  318.     
  319.     try:
  320.         import array
  321.     except ImportError:
  322.         return charset
  323.  
  324.     charmap = [
  325.         0] * 65536
  326.     negate = 0
  327.     
  328.     try:
  329.         for op, av in charset:
  330.             if op is NEGATE:
  331.                 negate = 1
  332.                 continue
  333.             if op is LITERAL:
  334.                 charmap[fixup(av)] = 1
  335.                 continue
  336.             if op is RANGE:
  337.                 for i in xrange(fixup(av[0]), fixup(av[1]) + 1):
  338.                     charmap[i] = 1
  339.                 
  340.             if op is CATEGORY:
  341.                 return charset
  342.                 continue
  343.     except IndexError:
  344.         return charset
  345.  
  346.     if negate:
  347.         if sys.maxunicode != 65535:
  348.             return charset
  349.         
  350.         for i in xrange(65536):
  351.             charmap[i] = not charmap[i]
  352.         
  353.     
  354.     comps = { }
  355.     mapping = [
  356.         0] * 256
  357.     block = 0
  358.     data = []
  359.     for i in xrange(256):
  360.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  361.         new = comps.setdefault(chunk, block)
  362.         mapping[i] = new
  363.         if new == block:
  364.             block = block + 1
  365.             data = data + _mk_bitmap(chunk)
  366.             continue
  367.     
  368.     header = [
  369.         block]
  370.     if _sre.CODESIZE == 2:
  371.         code = 'H'
  372.     else:
  373.         code = 'I'
  374.     mapping = array.array('b', mapping).tostring()
  375.     mapping = array.array(code, mapping)
  376.     header = header + mapping.tolist()
  377.     data[0:0] = header
  378.     return [
  379.         (BIGCHARSET, data)]
  380.  
  381.  
  382. def _simple(av):
  383.     (lo, hi) = av[2].getwidth()
  384.     if lo == 0 and hi == MAXREPEAT:
  385.         raise error, 'nothing to repeat'
  386.     
  387.     if hi == hi:
  388.         pass
  389.     elif hi == 1:
  390.         pass
  391.     return av[2][0][0] != SUBPATTERN
  392.  
  393.  
  394. def _compile_info(code, pattern, flags):
  395.     (lo, hi) = pattern.getwidth()
  396.     if lo == 0:
  397.         return None
  398.     
  399.     prefix = []
  400.     prefixappend = prefix.append
  401.     prefix_skip = 0
  402.     charset = []
  403.     charsetappend = charset.append
  404.     if not flags & SRE_FLAG_IGNORECASE:
  405.         for op, av in pattern.data:
  406.             if op is LITERAL:
  407.                 if len(prefix) == prefix_skip:
  408.                     prefix_skip = prefix_skip + 1
  409.                 
  410.                 prefixappend(av)
  411.                 continue
  412.             if op is SUBPATTERN and len(av[1]) == 1:
  413.                 (op, av) = av[1][0]
  414.                 if op is LITERAL:
  415.                     prefixappend(av)
  416.                 else:
  417.                     break
  418.             op is LITERAL
  419.         
  420.         if not prefix and pattern.data:
  421.             (op, av) = pattern.data[0]
  422.             if op is SUBPATTERN and av[1]:
  423.                 (op, av) = av[1][0]
  424.                 if op is LITERAL:
  425.                     charsetappend((op, av))
  426.                 elif op is BRANCH:
  427.                     c = []
  428.                     cappend = c.append
  429.                     for p in av[1]:
  430.                         if not p:
  431.                             break
  432.                         
  433.                         (op, av) = p[0]
  434.                         if op is LITERAL:
  435.                             cappend((op, av))
  436.                             continue
  437.                     else:
  438.                         charset = c
  439.                 
  440.             elif op is BRANCH:
  441.                 c = []
  442.                 cappend = c.append
  443.                 for p in av[1]:
  444.                     if not p:
  445.                         break
  446.                     
  447.                     (op, av) = p[0]
  448.                     if op is LITERAL:
  449.                         cappend((op, av))
  450.                         continue
  451.                 else:
  452.                     charset = c
  453.             elif op is IN:
  454.                 charset = av
  455.             
  456.         
  457.     
  458.     emit = code.append
  459.     emit(OPCODES[INFO])
  460.     skip = len(code)
  461.     emit(0)
  462.     mask = 0
  463.     if prefix:
  464.         mask = SRE_INFO_PREFIX
  465.         if prefix_skip == prefix_skip:
  466.             pass
  467.         elif prefix_skip == len(pattern.data):
  468.             mask = mask + SRE_INFO_LITERAL
  469.         
  470.     elif charset:
  471.         mask = mask + SRE_INFO_CHARSET
  472.     
  473.     emit(mask)
  474.     if lo < MAXCODE:
  475.         emit(lo)
  476.     else:
  477.         emit(MAXCODE)
  478.         prefix = prefix[:MAXCODE]
  479.     if hi < MAXCODE:
  480.         emit(hi)
  481.     else:
  482.         emit(0)
  483.     if prefix:
  484.         emit(len(prefix))
  485.         emit(prefix_skip)
  486.         code.extend(prefix)
  487.         table = [
  488.             -1] + [
  489.             0] * len(prefix)
  490.         for i in xrange(len(prefix)):
  491.             table[i + 1] = table[i] + 1
  492.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  493.                 table[i + 1] = table[table[i + 1] - 1] + 1
  494.         
  495.         code.extend(table[1:])
  496.     elif charset:
  497.         _compile_charset(charset, flags, code)
  498.     
  499.     code[skip] = len(code) - skip
  500.  
  501.  
  502. try:
  503.     unicode
  504. except NameError:
  505.     STRING_TYPES = (type(''),)
  506.  
  507. STRING_TYPES = (type(''), type(unicode('')))
  508.  
  509. def isstring(obj):
  510.     for tp in STRING_TYPES:
  511.         if isinstance(obj, tp):
  512.             return 1
  513.             continue
  514.     
  515.     return 0
  516.  
  517.  
  518. def _code(p, flags):
  519.     flags = p.pattern.flags | flags
  520.     code = []
  521.     _compile_info(code, p, flags)
  522.     _compile(code, p.data, flags)
  523.     code.append(OPCODES[SUCCESS])
  524.     return code
  525.  
  526.  
  527. def compile(p, flags = 0):
  528.     if isstring(p):
  529.         import sre_parse
  530.         pattern = p
  531.         p = sre_parse.parse(p, flags)
  532.     else:
  533.         pattern = None
  534.     code = _code(p, flags)
  535.     if p.pattern.groups > 100:
  536.         raise AssertionError('sorry, but this version only supports 100 named groups')
  537.     
  538.     groupindex = p.pattern.groupdict
  539.     indexgroup = [
  540.         None] * p.pattern.groups
  541.     for k, i in groupindex.items():
  542.         indexgroup[i] = k
  543.     
  544.     return _sre.compile(pattern, flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  545.  
  546.